﻿#include "Common.h"
#include "ConcurrentAllo.h"
using namespace std;
////单元测试
//void Alloc1()
//{
//	for (int i = 0; i < 6; i++)
//	{
//		void* ptr = ConcurrentAllo::ConcurrentAlloc(7);
//	}
//}
//
//void Allco2()
//{
//	for (int i = 0; i < 5; i++)
//	{
//		void* ptr = ConcurrentAllo::ConcurrentAlloc(6);
//	}
//}
//
//void TreadTest()
//{
//	std::thread t1(Alloc1);	//创建线程，比Linux简单多了
//	t1.join();
//	std::thread t2(Allco2);
//	t2.join();
//}
//
//
//void TestConcurrentAlloc1()
//{
//	void* p1 = ConcurrentAllo::ConcurrentAlloc(6);
//	void* p2 = ConcurrentAllo::ConcurrentAlloc(8);
//	void* p3 = ConcurrentAllo::ConcurrentAlloc(1);
//	void* p4 = ConcurrentAllo::ConcurrentAlloc(7);
//	void* p5 = ConcurrentAllo::ConcurrentAlloc(8);
//
//	cout << p1 << endl;
//	cout << p2 << endl;
//	cout << p3 << endl;
//	cout << p4 << endl;
//	cout << p5 << endl;
//}
//
//void TestConcurrentAlloc2()
//{
//	for (size_t i = 0; i < 1024; ++i)
//	{
//		void* p1 = ConcurrentAllo::ConcurrentAlloc(6);
//		cout << p1 << endl;
//	}
//
//	void* p2 = ConcurrentAllo::ConcurrentAlloc(8);
//	cout << p2 << endl;
//}
//
//int main()
//{
//	//TestObjectPool();
//	//TLSTest();
//
//	TestConcurrentAlloc2();
//
//	return 0;
//}
//#include <iostream>
//#include <thread>
//#include <vector>
//#include <chrono>
//
//#include "ConcurrentAllo.h"
//
//constexpr int THREAD_COUNT = 1500; // 少点儿线程先跑
//constexpr int OPS = 10000;       // 次数也少点儿
//
//void test_thread(int tid)
//{
//    for (int i = 0; i < OPS; ++i)
//    {
//        size_t size = 64; // 固定大小
//        void* ptr = nullptr;
//        try
//        {
//            ptr = ConcurrentAllo::ConcurrentAlloc(size);
//            if (!ptr)
//            {
//                std::cerr << "Thread " << tid << " alloc failed\n";
//                continue;
//            }
//            memset(ptr, tid, size);
//            ConcurrentAllo::ConcurrentFree(ptr, size);
//        }
//        catch (const std::exception& e)
//        {
//            std::cerr << "Exception in thread " << tid << ": " << e.what() << std::endl;
//            break;
//        }
//    }
//    std::cout << "Thread " << tid << " done.\n";
//}
//
//int main()
//{
//    std::vector<std::thread> threads;
//    for (int i = 0; i < THREAD_COUNT; ++i)
//        threads.emplace_back(test_thread, i + 1);
//    for (auto& t : threads)
//        t.join();
//
//    std::cout << "Basic multi-thread test done.\n";
//    return 0;
//}
//
//
//
//
//#include <iostream>
//#include <thread>
//#include <vector>
//#include "ThreadCache.h"
//#include "CentralCache.h"
//#include "PageCache.h"
//
//void TestAllocFree()
//{
//    ThreadCache tc;
//
//    // 申请一批小对象 (比如 64 字节)
//    std::vector<void*> objs;
//    size_t objSize = 64;
//
//    std::cout << "开始申请 10 个 " << objSize << " 字节的小对象" << std::endl;
//    for (int i = 0; i < 10; i++)
//    {
//        void* ptr = tc.Allocate(objSize);
//        objs.push_back(ptr);
//        std::cout << "分配对象 " << i << " 地址: " << ptr << std::endl;
//    }
//
//    std::cout << "\n开始释放这些对象..." << std::endl;
//    for (size_t i = 0; i < objs.size(); i++)
//    {
//        tc.Deallocate(objs[i], objSize);
//        std::cout << "释放对象 " << i << " 地址: " << objs[i] << std::endl;
//    }
//
//    std::cout << "\n测试完成 ✅" << std::endl;
//}
//
//int main()
//{
//    // 初始化单例
//    CentralCache::GetInstance();
//    PageCache::GetInstance();
//
//    // 单线程测试
//    TestAllocFree();
//
//    // 多线程测试
//    std::cout << "\n===== 多线程测试 =====\n";
//    auto work = []() {
//        ThreadCache tc;
//        for (int i = 0; i < 1000; i++)
//        {
//            void* ptr = tc.Allocate(128);
//            tc.Deallocate(ptr, 128);
//        }
//        };
//
//    std::thread t1(work);
//    std::thread t2(work);
//    std::thread t3(work);
//
//    t1.join();
//    t2.join();
//    t3.join();
//
//    std::cout << "多线程测试完成 ✅" << std::endl;
//
//    return 0;
//}

//#include <iostream>
//#include <thread>
//#include <vector>
//#include <random>
//#include <chrono>
//#include "ThreadCache.h"
//
//const int THREAD_COUNT = 64;        // 测试线程数
////const int ALLOC_TIMES = 1000000;   // 每个线程分配次数
//const int ALLOC_TIMES = 10000000;  // 每线程一千万次
//
//
//// 高压力测试任务
//void StressTestTask(int tid)
//{
//    std::default_random_engine engine((unsigned)time(nullptr) + tid);
//    std::uniform_int_distribution<size_t> dist(8, 10240); // 随机分配 [8, 1024] 字节
//
//    ThreadCache tc;
//
//    for (int i = 0; i < ALLOC_TIMES; ++i)
//    {
//        size_t size = dist(engine);
//        void* ptr = tc.Allocate(size);
//
//        // 模拟写点数据，确保内存真的可用
//        memset(ptr, tid, size < 16 ? size : 16);
//
//        // 释放
//        tc.Deallocate(ptr, size);
//
//        if (i % 200000 == 0)
//        {
//            std::cout << "线程 " << tid << " 已完成分配/释放次数: " << i << "\n";
//        }
//    }
//}
//
//int main()
//{
//    std::cout << "===== 高压力内存池测试 =====\n";
//
//    auto start = std::chrono::high_resolution_clock::now();
//
//    std::vector<std::thread> threads;
//    for (int i = 0; i < THREAD_COUNT; i++)
//    {
//        threads.emplace_back(StressTestTask, i);
//    }
//
//    for (auto& t : threads)
//    {
//        t.join();
//    }
//
//    auto end = std::chrono::high_resolution_clock::now();
//    std::chrono::duration<double> diff = end - start;
//
//    std::cout << "高压力测试完成，总耗时: " << diff.count() << " 秒\n";
//    return 0;
//}
//#include <iostream>
//#include <thread>
//#include <vector>
//#include <chrono>
//#include "ConcurrentAllo.h"   // 你项目里的头文件，保证包含 ConcurrentAlloc/ConcurrentFree
//
//
//using namespace std;
//
//void TestSmallObjects()
//{
//    cout << "===== 小对象测试 =====" << endl;
//    vector<void*> ptrs;
//
//    // 申请 10 个 64B 小对象
//    for (int i = 0; i < 10; i++)
//    {
//        void* p = ConcurrentAllo::ConcurrentAlloc(64);
//        cout << "分配小对象 " << i << " 地址: " << p << endl;
//        ptrs.push_back(p);
//    }
//
//    // 释放
//    for (int i = 0; i < 10; i++)
//    {
//        cout << "释放小对象 " << i << " 地址: " << ptrs[i] << endl;
//        ConcurrentAllo::ConcurrentFree(ptrs[i]);
//    }
//}
//
//void TestMediumObjects()
//{
//    cout << "\n===== 中等对象测试 (128KB) =====" << endl;
//    vector<void*> ptrs;
//
//    for (int i = 0; i < 5; i++)
//    {
//        void* p = ConcurrentAllo::ConcurrentAlloc(128 * 1024);
//        cout << "分配中等对象 " << i << " 地址: " << p << endl;
//        ptrs.push_back(p);
//    }
//
//    for (int i = 0; i < 5; i++)
//    {
//        cout << "释放中等对象 " << i << " 地址: " << ptrs[i] << endl;
//        ConcurrentAllo::ConcurrentFree(ptrs[i]);
//    }
//}
//
//void TestLargeObjects()
//{
//    cout << "\n===== 大对象测试 (1MB) =====" << endl;
//    vector<void*> ptrs;
//
//    for (int i = 0; i < 3; i++)
//    {
//        void* p = ConcurrentAllo::ConcurrentAlloc(1024 * 1024); // 1MB
//        cout << "分配大对象 " << i << " 地址: " << p << endl;
//        ptrs.push_back(p);
//    }
//
//    for (int i = 0; i < 3; i++)
//    {
//        cout << "释放大对象 " << i << " 地址: " << ptrs[i] << endl;
//        ConcurrentAllo::ConcurrentFree(ptrs[i]);
//    }
//}
//
//void ThreadStressTest(int id, int loopCount)
//{
//    for (int i = 0; i < loopCount; i++)
//    {
//        // 随机大小：小对象、中对象、大对象混合
//        size_t size;
//        if (i % 3 == 0) size = 64;            // 小对象
//        else if (i % 3 == 1) size = 128 * 1024; // 中等对象
//        else size = 1024 * 1024;              // 大对象
//
//        void* p = ConcurrentAllo::ConcurrentAlloc(size);
//        // 模拟业务逻辑消耗
//        if (i % 1000 == 0) this_thread::yield();
//
//        ConcurrentAllo::ConcurrentFree(p);
//    }
//    cout << "线程 " << id << " 压测完成" << endl;
//}
//
//void TestMultiThread()
//{
//    cout << "\n===== 多线程混合压力测试 =====" << endl;
//    const int threadCount = 8;
//    const int loopCount = 100000;
//
//    vector<thread> threads;
//    auto start = chrono::high_resolution_clock::now();
//
//    for (int i = 0; i < threadCount; i++)
//    {
//        threads.emplace_back(ThreadStressTest, i, loopCount);
//    }
//    for (auto& t : threads) t.join();
//
//    auto end = chrono::high_resolution_clock::now();
//    chrono::duration<double> diff = end - start;
//    cout << "压力测试完成，总耗时: " << diff.count() << " 秒" << endl;
//}
//
//int main()
//{
//    TestSmallObjects();
//    TestMediumObjects();
//    TestLargeObjects();
//    TestMultiThread();
//
//    cout << "所有测试完成 ✅" << endl;
//    return 0;
//}


